package com.boot.ys.mybatisplus.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.io.*;
import java.nio.file.*;

/**
 * 翻译表字段，实体类上添加@TableField注解映射
 *
 * @author: 杨升
 * @date: 2025-06-07 21:53
 * @Version 1.0
 */

public class AboFiled {

    public static void main(String[] args) throws IOException {
        // 实体类的位置
        String directoryPath = "C:\\Users\\Acer\\Desktop\\1\\springboot3txar\\src\\main\\java\\com\\entity";
        // xml的位置
        String xmlPath = "C:\\Users\\Acer\\Desktop\\1\\springboot3txar\\src\\main\\resources\\mapper";


        // key 拼音字段名 value 英文字段（带下划线）
        LinkedHashMap<String, String> hasMap = new LinkedHashMap<>();
        hasMap.put("gongsimingcheng", "corporate_name");

        // 更新实体类里面的字段添加@TableField注解
        updateEntityFiles(directoryPath, hasMap);
        // 更新XMl里面的更新表字段映射
        updateXmlFiled(hasMap, xmlPath);


        //!!!!!!!这是存储表数据!!!!!!!!!!!：key旧英文表名 value：英文表名带下划线
        LinkedHashMap<String, String> resultMap = new LinkedHashMap<>();
        resultMap.put("wuliugongsi", "corporate_name");
        // 更新XMl里面的ResultMap返回值
        updateResultValue(resultMap, xmlPath);
    }

    // 更新表字段
    static void updateXmlFiled(LinkedHashMap<String, String> hasMap, String xmlPath) throws IOException {
        for (Map.Entry<String, String> entry : hasMap.entrySet()) {
            String oldFiled = entry.getKey();
            String newFiled = entry.getValue();
            // 更新Xml里面的内容
            AboXmlFiled.updateXmlContent(xmlPath, oldFiled, newFiled, 1);
        }
    }

    static void updateResultValue(LinkedHashMap<String, String> hasMap, String xmlPath) throws IOException {
        for (Map.Entry<String, String> entry : hasMap.entrySet()) {
            String oldFiled = entry.getKey();

            // 英文字段名，转换为首字母下划线转驼峰
            String newFiled = toCamelCase(entry.getValue());
            // 更新Xml里面的内容
            AboXmlFiled.updateXmlContent(xmlPath, oldFiled, newFiled, 2);
        }
    }


    /**
     * 将字符串转换为驼峰式（PascalCase）
     * - 如果包含下划线，按 snake_case 转 PascalCase（如 "hot_spot" → "HotSpot"）
     * - 如果不包含下划线，直接首字母大写（如 "spot" → "Spot"）
     */
    public static String toCamelCase(String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }

        // 如果包含下划线，按 snake_case 处理
        if (input.contains("_")) {
            String[] parts = input.split("_");
            StringBuilder result = new StringBuilder();

            for (String part : parts) {
                if (!part.isEmpty()) {
                    // 每个单词首字母大写
                    result.append(Character.toUpperCase(part.charAt(0)));
                    if (part.length() > 1) {
                        result.append(part.substring(1).toLowerCase());
                    }
                }
            }
            return result.toString();
        }
        // 不包含下划线，直接首字母大写
        else {
            return Character.toUpperCase(input.charAt(0)) +
                    (input.length() > 1 ? input.substring(1).toLowerCase() : "");
        }
    }

    public static void updateEntityFiles(String directoryPath, LinkedHashMap<String, String> hasMap) {
        try {
            Files.walk(Paths.get(directoryPath))
                    .filter(Files::isRegularFile)
                    .filter(path -> path.toString().endsWith(".java"))
                    .forEach(file -> {
                        BufferedReader reader = null;
                        BufferedWriter writer = null;
                        try {
                            // JDK8文件读取方式
                            reader = Files.newBufferedReader(file);
                            StringBuilder content = new StringBuilder();
                            String line;
                            while ((line = reader.readLine()) != null) {
                                content.append(line).append("\n");
                            }

                            String modified = updateFields(content.toString(), hasMap);

                            if (!content.toString().equals(modified)) {
                                // JDK8文件写入方式
                                writer = Files.newBufferedWriter(file, StandardOpenOption.TRUNCATE_EXISTING);
                                writer.write(modified);
                                System.out.println("更新内容: " + file.getFileName());
                            }
                        } catch (Exception e) {
                            System.err.println("处理文件出错: " + file + " | " + e.getMessage());
                        } finally {
                            try {
                                if (reader != null) reader.close();
                            } catch (IOException e) {
                            }
                            try {
                                if (writer != null) writer.close();
                            } catch (IOException e) {
                            }
                        }
                    });
        } catch (IOException e) {
            System.err.println("目录访问错误: " + e.getMessage());
        }
    }

    private static String updateFields(String content, LinkedHashMap<String, String> hasMap) {
        StringBuilder result = new StringBuilder();
        String[] lines = content.split("\n");

        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];

            // 检查是否是字段定义行
            for (Map.Entry<String, String> entry : hasMap.entrySet()) {
                String field = entry.getKey();
                String column = entry.getValue();

                // 匹配任意类型的字段声明（如 private String xxx;）
                if (line.matches(".*private\\s+\\w+\\s*" + field + "\\s*;.*")) {

                    // 检查前一行是否已经是TableField注解
                    boolean needAddAnnotation = true;
                    if (i > 0) {
                        String prevLine = lines[i - 1].trim();
                        if (prevLine.startsWith("@TableField")) {
                            needAddAnnotation = false;
                        }
                    }

                    // 添加注解（保持缩进）
                    if (needAddAnnotation) {
                        String indent = line.substring(0, line.indexOf("private"));
                        result.append(indent).append("@TableField(value = \"").append(column).append("\")\n");
                    }
                }
            }
            result.append(line).append("\n");
        }

        return result.toString();
    }

}
